src/file.rs (1)

169-187: 💤 Low value

Consider adding trace logging for retry attempts.

The shims module logs when it encounters locked files (trace!("cannot delete locked shim...") in shims.rs). Adding similar logging here would aid debugging when installs are slow due to antivirus interference:

🔧 Suggested logging addition

 #[cfg(windows)]
 fn do_rename(from: &Path, to: &Path) -> std::io::Result<()> {
     const MAX_ATTEMPTS: u32 = 5;
     let mut last_err = None;
     for attempt in 0..MAX_ATTEMPTS {
         match fs::rename(from, to) {
             Ok(()) => return Ok(()),
             Err(e) if matches!(e.raw_os_error(), Some(5) | Some(32)) => {
                 // ERROR_ACCESS_DENIED (5) or ERROR_SHARING_VIOLATION (32):
                 // likely a transient lock from antivirus or the OS.
                 // Exponential backoff: 50ms, 100ms, 200ms, 400ms, 800ms
+                trace!(
+                    "rename {} -> {} failed with OS error {}, retrying ({}/{})",
+                    from.display(),
+                    to.display(),
+                    e.raw_os_error().unwrap_or(-1),
+                    attempt + 1,
+                    MAX_ATTEMPTS
+                );
                 last_err = Some(e);
                 std::thread::sleep(std::time::Duration::from_millis(50 * (1 << attempt)));
             }
             Err(e) => return Err(e),
         }
     }
     Err(last_err.unwrap())
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/file.rs` around lines 169 - 187, The do_rename function retries on
Windows but doesn't log retry attempts; add trace-level logging inside the
Err(e) branch that matches ERROR_ACCESS_DENIED/ERROR_SHARING_VIOLATION so each
retry reports the attempt number, the from and to paths, the error and the
backoff duration (use the same 50ms * (1 << attempt) calculation) using the
trace! macro (referencing do_rename, the loop's attempt variable, from and to
Path values, and the local e) and also add a final trace or debug log before
returning Err(last_err.unwrap()) to record the ultimate failure.

src/file.rs (1)

169-194: 💤 Low value

Consider adding trace logging on retry attempts.

When transient lock failures trigger retries, there's no visibility into the retry loop. Adding a trace! log (similar to the pattern in shims.rs at line 271) would help diagnose intermittent Windows installation failures.

🔧 Suggested trace logging

             Err(e) if matches!(e.raw_os_error(), Some(5) | Some(32)) => {
                 // ERROR_ACCESS_DENIED (5) or ERROR_SHARING_VIOLATION (32):
                 // likely a transient lock from antivirus or the OS.
                 // Exponential backoff: 50ms, 100ms, 200ms, 400ms, 800ms
                 last_err = Some(e);
                 if attempt + 1 < MAX_ATTEMPTS {
+                    trace!(
+                        "rename {} -> {} blocked by transient lock, retrying ({}/{})",
+                        from.display(),
+                        to.display(),
+                        attempt + 1,
+                        MAX_ATTEMPTS
+                    );
                     std::thread::sleep(std::time::Duration::from_millis(50 * (1 << attempt)));
                 }
             }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/file.rs` around lines 169 - 194, Add trace-level logging inside the
Windows retry branch of do_rename to surface each transient retry: in the Err(e)
if matches!(e.raw_os_error(), Some(5) | Some(32)) arm (inside fn do_rename),
call trace! with the attempt number, MAX_ATTEMPTS, the error (e), and the
from/to paths and computed backoff duration (follow the trace pattern used in
shims.rs around the retry on line 271) before sleeping so each retry and its
reason are visible for diagnostics.